Node / ReticulumProjects / Reticulum.git / files / docs / source / whatis.rst

Displaying Raw • Download

Tc9d1d9******************

Tc9d1d9What is Reticulum?

Tc9d1d9******************

Reticulum is a cryptography-based networking stack for building both local and

wide-area networks with readily available hardware, that can continue to operate

under adverse conditions, such as extremely low bandwidth and very high latency.

To understand the foundational philosophy and goals of this system, read the

Te6edf3:ref:Te6edf3`Zen of Reticulum <zen>`.

Reticulum allows you to build wide-area networks with off-the-shelf tools, and

offers end-to-end encryption, forward secrecy, autoconfiguring cryptographically

backed multi-hop transport, efficient addressing, unforgeable packet

acknowledgements and more.

From a users perspective, Reticulum allows the creation of applications that

respect and empower the autonomy and sovereignty of communities and individuals.

Reticulum enables secure digital communication that cannot be subjected to

outside control, manipulation or censorship.

Reticulum enables the construction of both small and potentially planetary-scale

networks, without any need for hierarchical or bureaucratic structures to control

or manage them, while ensuring individuals and communities full sovereignty

over their own network segments.

Reticulum is a **complete networking stack**, and does not need IP or higher

layers, although it is easy to utilise IP (with TCP or UDP) as the underlying

carrier for Reticulum. It is therefore trivial to tunnel Reticulum over the

Internet or private IP networks. Reticulum is built directly on cryptographic

principles, allowing resilience and stable functionality in open and trustless

networks.

No kernel modules or drivers are required. Reticulum can run completely in

userland, and will run on practically any system that runs Python 3. Reticulum

runs well even on small single-board computers like the Pi Zero.

Tc9d1d9Current Status

Tc9d1d9==============

All core protocol features are implemented and functioning, but additions will probably occur as

real-world use is explored. The API and wire-format can be considered complete and stable, but

could change if absolutely warranted.

Tc9d1d9Reference Implementation

Tc9d1d9========================

The Python code, for which this documentation is written, and known as the Reticulum Network Stack,

is the Reference Implementation of Reticulum. The Reticulum Protocol is defined entirely

and authoritatively by this reference implementation, and this manual. It is maintained by Mark Qvist,

identified by the Reticulum Identity Ta5d6ff``Ta5d6ff<bc7291552be7a58f361522990465165c>Ta5d6ff``.

Compatibility with the Reticulum Protocol is defined as having full interoperability,

and sufficient functional parity with this reference implementation. Any specific protocol

implementation that achieves this is Reticulum. Any that does not is not Reticulum.

The reference implementation is licensed under the Te6edf3:ref:Te6edf3`Reticulum License <license>`.

The Reticulum Protocol was dedicated to the Public Domain in 2016.

Tc9d1d9What does Reticulum Offer?

Tc9d1d9==========================

T79c0ff* Coordination-less globally unique addressing and identification

T79c0ff* Fully self-configuring multi-hop routing over heterogeneous carriers

T79c0ff* Flexible scalability over heterogeneous topologies

T79c0ff* Reticulum can carry data over any mixture of physical mediums and topologies

T79c0ff* Low-bandwidth networks can co-exist and interoperate with large, high-bandwidth networks

T79c0ff* Initiator anonymity, communicate without revealing your identity

T79c0ff* Reticulum does not include source addresses on any packets

T79c0ff* Asymmetric X25519 encryption and Ed25519 signatures as a basis for all communication

T79c0ff* The foundational Reticulum Identity Keys are 512-bit Elliptic Curve keysets

T79c0ff* Forward Secrecy is available for all communication types, both for single packets and over links

T79c0ff* Reticulum uses the following format for encrypted tokens:

T79c0ff* Ephemeral per-packet and link keys and derived from an ECDH key exchange on Curve25519

T79c0ff* AES-256 in CBC mode with PKCS7 padding

T79c0ff* HMAC using SHA256 for authentication

T79c0ff* IVs are generated through os.urandom()

T79c0ff* Unforgeable packet delivery confirmations

T79c0ff* Flexible and extensible interface system

T79c0ff* Reticulum includes a large variety of built-in interface types

T79c0ff* Ability to load and utilise custom user- or community-supplied interface types

T79c0ff* Easily create your own custom interfaces for communicating over anything

T79c0ff* Authentication and virtual network segmentation on all supported interface types

T79c0ff* An intuitive and easy-to-use API

T79c0ff* Simpler and easier to use than sockets APIs and simpler, but more powerful

T79c0ff* Makes building distributed and decentralised applications much simpler

T79c0ff* Reliable and efficient transfer of arbitrary amounts of data

T79c0ff* Reticulum can handle a few bytes of data or files of many gigabytes

T79c0ff* Sequencing, compression, transfer coordination and checksumming are automatic

T79c0ff* The API is very easy to use, and provides transfer progress

T79c0ff* Lightweight, flexible and expandable Request/Response mechanism

T79c0ff* Efficient link establishment

T79c0ff* Total cost of setting up an encrypted and verified link is only 3 packets, totalling 297 bytes

T79c0ff* Low cost of keeping links open at only 0.44 bits per second

T79c0ff* Reliable sequential delivery with Channel and Buffer mechanisms

Tc9d1d9Where can Reticulum be Used?

Tc9d1d9============================

Over practically any medium that can support at least a half-duplex channel

with greater throughput than 5 bits per second, and an MTU of 500 bytes. Data radios,

modems, LoRa radios, serial lines, AX.25 TNCs, amateur radio digital modes,

ad-hoc WiFi, free-space optical links and similar systems are all examples

of the types of interfaces Reticulum was designed for.

An open-source LoRa-based interface called Ta5d6ff`RNode Tffd700<https://unsigned.io/rnode>Ta5d6ff`_

has been designed as an example transceiver that is very suitable for

Reticulum. It is possible to build it yourself, to transform a common LoRa

development board into one, or it can be purchased as a complete transceiver

from various vendors.

Reticulum can also be encapsulated over existing IP networks, so there's

nothing stopping you from using it over wired Ethernet or your local WiFi

network, where it'll work just as well. In fact, one of the strengths of

Reticulum is how easily it allows you to connect different mediums into a

self-configuring, resilient and encrypted mesh.

As an example, it's possible to set up a Raspberry Pi connected to both a

LoRa radio, a packet radio TNC and a WiFi network. Once the interfaces are

added, Reticulum will take care of the rest, and any device on the WiFi

network can communicate with nodes on the LoRa and packet radio sides of the

network, and vice versa.

Tc9d1d9Interface Types and Devices

Tc9d1d9===========================

Reticulum implements a range of generalised interface types that covers the communications hardware that Reticulum can run over. If your hardware is not supported, it's simple to Te6edf3:ref:Te6edf3`implement an interface class<example-custominterface>`. Currently, Reticulum can use the following devices and communication mediums:

T79c0ff* Any Ethernet device

T79c0ff* WiFi devices

T79c0ff* Wired Ethernet devices

T79c0ff* Fibre-optic transceivers

T79c0ff* Data radios with Ethernet ports

T79c0ff* LoRa using Ta5d6ff`RNode Tffd700<https://unsigned.io/rnode>Ta5d6ff`_

T79c0ff* Can be installed on Ta5d6ff`many popular LoRa boards Tffd700<https://github.com/markqvist/rnodeconfigutil#supported-devices>Ta5d6ff`_

T79c0ff* Can be purchased as a Ta5d6ff`ready to use transceiver Tffd700<https://unsigned.io/rnode>Ta5d6ff`_

T79c0ff* Packet Radio TNCs, such as Ta5d6ff`OpenModem Tffd700<https://unsigned.io/openmodem>Ta5d6ff`_

T79c0ff* Any packet radio TNC in KISS mode

T79c0ff* Ideal for VHF and UHF radio

T79c0ff* Any device with a serial port

T79c0ff* The I2P network

T79c0ff* TCP over IP networks

T79c0ff* UDP over IP networks

T79c0ff* Anything you can connect via stdio

T79c0ff* Reticulum can use external programs and pipes as interfaces

T79c0ff* This can be used to easily hack in virtual interfaces

T79c0ff* Or to quickly create interfaces with custom hardware

T79c0ff* Anything else using Te6edf3:ref:Te6edf3`custom interface modules<interfaces-custom>` written in Python

For a full list and more details, see the Te6edf3:ref:Te6edf3`Supported Interfaces<interfaces-main>` chapter.